using System;
using System.Collections.Generic;
using Csla;
using Ent.AccesoDatos;
using System.Data;
using EntGuayasSLA.BL.Listas;
using EntGuayasSLA.BL.Listas.Criterias;

namespace EntGuayasSLA.BL
{
    /// <summary>
    /// Estereotipo: ReadOnlyList
    /// Reponsabilidad: 
    /// Autor: Diana Ortega
    /// Fecha: 15:33 17/06/2013
    /// </summary>
    [Serializable]
    public class ArchivoLista : ReadOnlyListBase<ArchivoLista, ArchivoInfo>
    {
        #region Authorization Rules
        private static int _nCountTmp;
        private static void AddObjectAuthorizationRules()
        {
            // TODO: add authorization rules
            //AuthorizationRules.AllowGet(typeof(FaseLista), "Role");
        }

        #endregion

        #region Factory Methods

     
        //
        public static ArchivoLista GetArchivoLista(ArchivoFasesCriteria filter)
        {
            return DataPortal.Fetch<ArchivoLista>(filter);
        }

        /// <summary>
        /// Obtener archivos
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public static ArchivoLista GetArchivoLista(ArchivoGlobalCriteria filter)
        {
            return DataPortal.Fetch<ArchivoLista>(filter);
        }
      
        /// <summary>
        /// Obtener los archivos con versiones
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public static ArchivoLista GetArchivoLista(ArchivoSubArchivosCriteria arcsub)
        {

            return DataPortal.Fetch<ArchivoLista>(arcsub);
        }
        /// <summary>
        /// Obtine todos los archivos exepto los archivos por revisar
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public static ArchivoLista GetArchivoLista(ArchivoCriteria filter)
        {
            return DataPortal.Fetch<ArchivoLista>(filter);
        }
        /// <summary>
        /// Obtiene los archivos asignados a revizar
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public static ArchivoLista GetArchivoLista(ArchivoRevisorCriteria filter)
        {
            return DataPortal.Fetch<ArchivoLista>(filter);
        }
        public static ArchivoLista GetArchivoLista(ArchivoEmisorCriteria filter)
        {
            return DataPortal.Fetch<ArchivoLista>(filter);
        }
        /// <summary>
        /// Obtiene los archivos asignados a un expedinte
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public static ArchivoLista GetArchivoLista(ArchivoExpedienteCriteria filter)
        {
            return DataPortal.Fetch<ArchivoLista>(filter);
        }
        /// <summary>
        /// Obtiene los archivos asignados a revizar
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public static ArchivoLista GetArchivoLista(ArchivoFirmarCriteria filter)
        {
            return DataPortal.Fetch<ArchivoLista>(filter);
        }
        /// <summary>
        /// Obtiene los archivos asignados a una persona
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public static ArchivoLista GetArchivoLista(string filter, out int nCountNuevo)
        {
            var lReturn = DataPortal.Fetch<ArchivoLista>(filter);
            nCountNuevo = _nCountTmp;
            return lReturn;
        }
        public ArchivoLista()
        { /* require use of factory methods */ }

        #endregion

        #region Data Access
        //
        private void DataPortal_Fetch(ArchivoFasesCriteria criteria)
        {
            RaiseListChangedEvents = false;
            IsReadOnly = false;
            var accesoDatos = new DriveDataBase(TypeDataBase.PostgreSql);
            var parametros = new List<Parametro> 
            {                   
                        new Parametro("ec_fas_id",criteria.FaseId),
                        new Parametro("ac_table",criteria.Tabla)
            };
            DataSet datos = accesoDatos.EjecutarDataSet("\"LISTA_ARCHIVOS_FASES\"", parametros);

            foreach (DataRow items in datos.Tables[0].Rows)
            {

                this.Add(ArchivoInfo.GetArchivoInfo(items));//, criteria.Tabla
            }
            IsReadOnly = true;
            RaiseListChangedEvents = true;
        }
        private void DataPortal_Fetch(ArchivoEmisorCriteria criteria)
        {
            RaiseListChangedEvents = false;
            IsReadOnly = false;
            var accesoDatos = new DriveDataBase(TypeDataBase.PostgreSql);
            var parametros = new List<Parametro> 
            {                   
                        new Parametro("ec_emisor",criteria.EmisorId),
                        new Parametro("ec_inf_estado",criteria.Estado)
            };
            DataSet datos = accesoDatos.EjecutarDataSet("\"LISTA_ARCHIVOS_COMENTARIOS\"", parametros);

            foreach (DataRow items in datos.Tables[0].Rows)
            {

                this.Add(ArchivoInfo.GetArchivoInfo(items));//, criteria.Tabla
            }
            IsReadOnly = true;
            RaiseListChangedEvents = true;
        }

       
        private void DataPortal_Fetch(ArchivoGlobalCriteria criteria)
        {
            RaiseListChangedEvents = false;
            IsReadOnly = false;
            var accesoDatos = new DriveDataBase(TypeDataBase.PostgreSql);
            var parametros = new List<Parametro> 
            {
                        new Parametro("ec_fal_id",criteria.FaseId),
                        new Parametro("ec_exp_id",criteria.ExpedienteId),
                        new Parametro("ec_table",criteria.Tabla)
            };
            DataSet datos = accesoDatos.EjecutarDataSet("\"LISTA_ARCHIVOS\"", parametros);
           
            foreach (DataRow items in datos.Tables[0].Rows)
            {

                this.Add(ArchivoInfo.GetArchivoInfo(items));//, criteria.Tabla
            }
            IsReadOnly = true;
            RaiseListChangedEvents = true;
        }
        private void DataPortal_Fetch(ArchivoSubArchivosCriteria criteria)
        {
            RaiseListChangedEvents = false;
            IsReadOnly = false;
            var accesoDatos = new DriveDataBase(TypeDataBase.PostgreSql);
            var parametros = new List<Parametro> 
                    {
                        new Parametro("ec_arc_referencia", criteria.Id),
                         new Parametro("ec_table",criteria.Tabla)
                    };
            DataSet datos = accesoDatos.EjecutarDataSet("\"LISTA_SUBARCHIVOS\"", parametros);
            foreach (DataRow items in datos.Tables[0].Rows)
            {
                this.Add(ArchivoInfo.GetArchivoInfo(items));//, criteria.Tabla
            }
            IsReadOnly = true;
            RaiseListChangedEvents = true;
        }
        private void DataPortal_Fetch(ArchivoCriteria criteria)
        {
            RaiseListChangedEvents = false;
            //IsReadOnly = false;
        
            var accesoDatos = new DriveDataBase(TypeDataBase.PostgreSql);
            var parametros = new List<Parametro> 
            {
                new Parametro("ec_fal_id", criteria.FaseId),
                new Parametro("ec_exp_id", criteria.ExpedienteId),
                new Parametro("ec_arc_tipo_documento", criteria.TipoDocumento)
            };
            DataSet datos = accesoDatos.EjecutarDataSet("\"LISTA_ARCHIVOS_TIPO\"", parametros);
            foreach (DataRow items in datos.Tables[0].Rows)
            {
                 this.Add(ArchivoInfo.GetArchivoInfo(items));               
            }
            //IsReadOnly = true;
            RaiseListChangedEvents = true;
        }
        /// <summary>
        /// Archivos por firmar
        /// </summary>
        /// <param name="criteria"></param>
        private void DataPortal_Fetch(ArchivoFirmarCriteria criteria)
        {
            RaiseListChangedEvents = false;
            IsReadOnly = false;
            var accesoDatos = new DriveDataBase(TypeDataBase.PostgreSql);
            var parametros = new List<Parametro> 
            {
                new Parametro("ec_fal_id", criteria.FaseId),             
                new Parametro("ec_arc_requiere_firma", criteria.RequiereFirma),
                new Parametro("ec_arc_firmado",criteria.Firmado)     
            };
            DataSet datos = accesoDatos.EjecutarDataSet("\"LISTA_ARCHIVOS_FIRMAR\"", parametros);
            foreach (DataRow items in datos.Tables[0].Rows)
            {
                this.Add(ArchivoInfo.GetArchivoInfo(items));
            }
            IsReadOnly = true;
            RaiseListChangedEvents = true;
        }
        private void DataPortal_Fetch(ArchivoRevisorCriteria criteria)
        {
            RaiseListChangedEvents = false;
            IsReadOnly = false;
            var accesoDatos = new DriveDataBase(TypeDataBase.PostgreSql);
            var parametros = new List<Parametro> 
            {
                //new Parametro("ec_fal_id", criteria.FaseId),                
                new Parametro("ec_ref_aprobado", criteria.Aprobado),
                new Parametro("ec_revisor", criteria.RevisorId),
                new Parametro("ec_inf_estado", criteria.Estado)
            };
            DataSet datos = accesoDatos.EjecutarDataSet("\"LISTA_ARCHIVOS_REVIZAR\"", parametros);
            foreach (DataRow items in datos.Tables[0].Rows)
            {
                this.Add(ArchivoInfo.GetArchivoInfo(items));
            }
           IsReadOnly = true;
           RaiseListChangedEvents = true;
        }
        private void DataPortal_Fetch(string criteria)
        {
            RaiseListChangedEvents = false;
            IsReadOnly = false;
            _nCountTmp = 0;
            var accesoDatos = new DriveDataBase(TypeDataBase.PostgreSql);
            var parametros = new List<Parametro> 
            {
                new Parametro("ec_per_id", criteria)             
                  
            };
            DataSet datos = accesoDatos.EjecutarDataSet("\"LISTA_ARCHIVOS_PERSONA\"", parametros);
            foreach (DataRow items in datos.Tables[0].Rows)
            {
                var info = ArchivoInfo.GetArchivoInfo(items);
                this.Add(info);
                if (info.SubirNuevo == "S")
                {
                    _nCountTmp += 1;
                }
            }
            //IsReadOnly = true;
            RaiseListChangedEvents = true;
        }
        private void DataPortal_Fetch(ArchivoExpedienteCriteria criteria)
        {
            RaiseListChangedEvents = false;
            IsReadOnly = false;
            var accesoDatos = new DriveDataBase(TypeDataBase.PostgreSql);
            var parametros = new List<Parametro> 
                    {  new Parametro("ec_exp_id",criteria.ExpedienteId),
                       new Parametro("ec_exp_estado", criteria.Estado)
                    };
            DataSet datos = accesoDatos.EjecutarDataSet("\"LISTA_ARCHIVOS_EXPEDIENTE\"", parametros);
            foreach (DataRow items in datos.Tables[0].Rows)
            {
                this.Add(ArchivoInfo.GetArchivoInfo(items));
            }
            IsReadOnly = true;
            RaiseListChangedEvents = true;
        }
        #endregion

        public void CopyTo(ItemLista ListaItemsCopy, int index, Boolean TipoDocEqualId)
        {
            IsReadOnly = false;
            foreach (ItemInfo item in ListaItemsCopy)
            {
                ArchivoInfo infoCopy = new ArchivoInfo();
                infoCopy.Copy(item, TipoDocEqualId);
                this.Insert(index, infoCopy);
            }
            
        }
    }
   
    /// <summary>
    /// Estereotipo: ReadOnlyChild
    /// Reponsabilidad: 
    /// Autor: Diana Ortega
    /// Fecha: 15:33 17/06/2013
    /// </summary>
    [Serializable]
    public class ArchivoInfo : ReadOnlyBase<ArchivoInfo>
    {
        #region Business Methods

        public Guid Id { get; internal set; }
        public string Nombre { get; internal set; }
        public string Descripcion{ get; internal set; }
        public DateTime FechaCreacion{ get; internal set; }
        public string RequiereFirmar { get; internal set; }
        public string Firmado { get; internal set; }
        public DateTime FechaFirmado { get; internal set; }
        public string TipoDocumento { get; internal set; }      
        public int Version { get; internal set; }
        public string Referencia { get; internal set; }
        public string Ruta { get;  set; }
        public string SubirNuevo { get; internal set; }
        public string Comentarios{ get; internal set; }
        public Guid PersonaId { get; internal set; }
        public string PersonaNombres { get; internal set; }
        public Guid  FaseLicId { get; internal set; }
        public Guid AuditoriaId { get; internal set; }
        public Guid ExpedienteId { get; internal set; }
        public Guid RevicionFaseId { get; internal set; }
        public string TipoDocumentoNombre { get; internal set; }
        public int Orden { get { return (Version); } }
        public Guid ArchivoId { get { return (Id); } }
        public string TablaInfo { get; internal set; }
        public string EstadoInforme { get; internal set; }
        public string AprobadoRevision { get; internal set; }     
        public string IdRevision{ get; internal set; }
        public string IdInforme { get; internal set; }
        public string CodigoFase { get; internal set; }
        public string TablaId { get; internal set; }
        public string NombreExpediente { get; internal set; }
        public string Fase { get; internal set; }
        #endregion 

        #region Factory Methods

        internal static ArchivoInfo GetArchivoInfo(DataRow childData)
        {
            return DataPortal.FetchChild<ArchivoInfo>(childData);
        }
        //internal static ArchivoInfo GetArchivoInfo(DataRow childData,string sNameTabla)
        //{
        //    return DataPortal.FetchChild<ArchivoInfo>(childData, sNameTabla);
        //}
      

        public ArchivoInfo()
        { /* require use of factory methods */ }

        #endregion

        #region Data Access

        private void Child_Fetch(DataRow childData)//,string sNameTabla
        {
            if (childData.Table.Columns.Contains("arc_id"))
                Id = Guid.Parse(childData["arc_id"].ToString());
            if (childData.Table.Columns.Contains("arc_nombre"))
                Nombre = childData["arc_nombre"].ToString();
            if (childData.Table.Columns.Contains("arc_descripcion"))
                Descripcion= childData["arc_descripcion"].ToString();
            if (childData.Table.Columns.Contains("arc_fecha_creacion"))
                FechaCreacion= DateTime.Parse(childData["arc_fecha_creacion"].ToString());
            if (childData.Table.Columns.Contains("arc_requiere_firma"))
                RequiereFirmar = childData["arc_requiere_firma"].ToString().Trim();
            if (childData.Table.Columns.Contains("arc_firmado"))
                Firmado= childData["arc_firmado"].ToString().Trim();
            if (childData.Table.Columns.Contains("arc_fecha_firmado"))
                FechaFirmado = DateTime.Parse(childData["arc_fecha_firmado"].ToString());
            if (childData.Table.Columns.Contains("arc_tipo_documento"))
                TipoDocumento= childData["arc_tipo_documento"].ToString();
            if (childData.Table.Columns.Contains("arc_version"))
                Version = int.Parse( childData["arc_version"].ToString());
            if (childData.Table.Columns.Contains("arc_referencia"))
                Referencia = childData["arc_referencia"].ToString();
            if (childData.Table.Columns.Contains("arc_ruta"))
                Ruta = childData["arc_ruta"].ToString();
            if (childData.Table.Columns.Contains("arc_cambiar"))
                SubirNuevo = childData["arc_cambiar"].ToString();
            if (childData.Table.Columns.Contains("arc_comentario"))
                Comentarios = childData["arc_comentario"].ToString();            
            if (childData.Table.Columns.Contains("per_id"))
                PersonaId = Guid.Parse(childData["per_id"].ToString());
            if (childData.Table.Columns.Contains("nombres"))
                PersonaNombres = childData["nombres"].ToString();
            if (childData.Table.Columns.Contains("exp_id"))
            {
                ExpedienteId = Guid.Parse(childData["exp_id"].ToString());
            }
            if (childData.Table.Columns.Contains("ref_id"))
                RevicionFaseId = Guid.Parse(childData["ref_id"].ToString());              
            //Id fase licenciamiento
            if (childData.Table.Columns.Contains("fal_id") && childData["fal_id"].ToString()!="")
                FaseLicId = Guid.Parse(childData["fal_id"].ToString());
            //Id direntes fases de audtoria
            if (childData.Table.Columns.Contains("fac_id") && childData["fac_id"].ToString() != "")
                AuditoriaId = Guid.Parse(childData["fac_id"].ToString());
            if (childData.Table.Columns.Contains("cpm_id") && childData["cpm_id"].ToString() != "")
                AuditoriaId = Guid.Parse(childData["cpm_id"].ToString());
            if (childData.Table.Columns.Contains("otr_id") && childData["otr_id"].ToString() != "")
                AuditoriaId = Guid.Parse(childData["otr_id"].ToString());

           if (childData.Table.Columns.Contains("rfl_nombre"))
               TipoDocumentoNombre = childData["rfl_nombre"].ToString();
           //Informe
           if (childData.Table.Columns.Contains("inf_estado"))
               EstadoInforme = childData["inf_estado"].ToString();
           //Revision Fase
           if (childData.Table.Columns.Contains("ref_aprobado"))
               AprobadoRevision = childData["ref_aprobado"].ToString();
           //Referencia a nombre de la tabla asociada a archivo
           //TablaInfo = sNameTabla;
           if (childData.Table.Columns.Contains("tipoTabla"))
               TablaInfo = childData["tipoTabla"].ToString();
            //
           if (childData.Table.Columns.Contains("inf_id"))
               IdInforme = childData["inf_id"].ToString();
           //Revision Fase
           if (childData.Table.Columns.Contains("ref_id"))
               IdRevision = childData["ref_id"].ToString();
           //Codigo Fase
           if (childData.Table.Columns.Contains("codigo_fase"))
               CodigoFase = childData["codigo_fase"].ToString();
           //exp_nombre
           if (childData.Table.Columns.Contains("exp_nombre"))
               NombreExpediente = childData["exp_nombre"].ToString();
            switch (TablaInfo)
            {
                case Valores.Modulo_Archivo_Informes_Licenciamiento:
                    Fase = "Licenciamiento - " +CodigoFase;
                    TablaId = childData["fal_id"].ToString();
                    break;
                case Valores.Modulo_Archivo_Informes_Aud_Cump:
                    Fase = "Auditoria - " + CodigoFase;
                    TablaId = childData["fac_id"].ToString();
                    break;
                case Valores.Modulo_Archivo_Informes_Aud_Moni:
                    Fase = "Monitoreo";
                    TablaId = childData["mon_id"].ToString();
                    break;
                case Valores.Modulo_Archivo_Informes_Aud_Pma:
                    Fase = "Cumplimiento PMA";
                    TablaId = childData["cpm_id"].ToString();
                    break;
                case Valores.Modulo_Archivo_Informes_Aud_Otro:
                    Fase = "Otros";
                    TablaId = childData["otr_id"].ToString();
                    break;
            }
        
        }
        #endregion
        internal void Copy(ItemInfo item, Boolean TipoDocEqualId)
        {
            if (TipoDocEqualId)
                TipoDocumento = item.Id.ToString();
            Id = item.Id;
            Nombre = item.Nombre;
            Descripcion = item.Descripcion;
            //FechaCreacion = ;
            RequiereFirmar = "N";
            Firmado = "N";
            //FechaFirmado = ;
            //TipoDocumento = ;
            Version = 0;//Inicializar en Cero, campo se lo utiliza en determinado caso como contador
            //Referencia = ;
            //Ruta = ;
            //SubirNuevo = ;
            //Comentarios = ;
            //PersonaId = ;
            //PersonaNombres = ;            
            //FaseLicId = ;            
            //ExpedienteId = ;
            //RevicionFaseId =;
            //TipoDocumentoNombre=;
        }

    }
   




}
